home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 07 - 1991 / 07.05 May 91 / Math Parser ƒ / ParserProcs / ParserOps < prev   
Encoding:
Text File  |  1990-10-04  |  5.7 KB  |  361 lines  |  [TEXT/PJMM]

  1. unit ParserOps;
  2.  
  3.  
  4. interface
  5.  
  6.  
  7.     uses
  8.  
  9.         ParserGlobals;
  10.  
  11.     procedure setdecimal;
  12.  
  13.     procedure readtfile;
  14.  
  15.     procedure createtfile (var savename: stringsize);
  16.  
  17.     procedure listtfiles;
  18.  
  19.     procedure listtfile (var savename: stringsize);
  20.  
  21.     procedure clearscreen (var line: str255);
  22.  
  23.     procedure readvariables;
  24.  
  25.     procedure listvariables;
  26.  
  27.     procedure deletevariable (var savename: stringsize);
  28.  
  29.     procedure storevariables;
  30.  
  31.  
  32. implementation
  33.  
  34.  
  35.     procedure setdecimal;
  36.  
  37.     begin
  38.         writeln('set number of decimal places to');
  39.         write(blank);
  40.         readln(decplace);
  41.         decplaceplus10 := decplace + 10;
  42.     end;
  43.  
  44.  
  45.     procedure readtfile;
  46.  
  47.         var
  48.             i: integer;
  49.  
  50.     begin
  51.  
  52.         for i := 1 to maxnumberfiles do
  53.             tfilename^^[i] := '';
  54.  
  55.         numfilename := 'numfiles';
  56.         open(numfile, numfilename);
  57.  
  58.         reset(numfile);
  59.         if not eof(numfile) then
  60.             readln(numfile, numberfiles);
  61.         if numberfiles <> 0 then
  62.             for i := 1 to numberfiles do
  63.                 readln(numfile, tfilename^^[i]);
  64.         close(numfile);
  65.  
  66.     end;
  67.  
  68.  
  69.     procedure createtfile;
  70.  
  71.         label
  72.             1;
  73.  
  74.         var
  75.             i, k: integer;
  76.             line: str255;
  77.  
  78.     begin
  79.  
  80.         for i := 1 to numberfiles do
  81.             if tfilename^^[i] = savename then
  82.                 begin
  83.                     k := i;
  84.                     goto 1;
  85.                 end;
  86.  
  87.         numberfiles := numberfiles + 1;
  88.         k := numberfiles;
  89.         tfilename^^[k] := savename;
  90.  
  91. 1:
  92.         if not tfileopen^^[k] then
  93.             begin
  94.                 open(tfile^^[k], tfilename^^[k]);
  95.                 tfileopen^^[k] := true;
  96.             end;
  97.         rewrite(tfile^^[k]);
  98.  
  99.         repeat
  100.             write(blank);
  101.             readln(line);
  102.             if length(line) <> 0 then
  103.                 writeln(tfile^^[k], line);
  104.         until length(line) = 0;
  105.  
  106.         close(tfile^^[k]);
  107.         tfileopen^^[k] := false;
  108.  
  109.         open(numfile, numfilename);
  110.         rewrite(numfile);
  111.  
  112.         writeln(numfile, numberfiles);
  113.  
  114.         for i := 1 to numberfiles do
  115.             writeln(numfile, tfilename^^[i]);
  116.  
  117.         close(numfile);
  118.  
  119.     end;
  120.  
  121.  
  122.  
  123.     procedure listtfiles;
  124.  
  125.         var
  126.             i, j, k: integer;
  127.             flag: hdlflagtype;
  128.  
  129.     begin
  130.  
  131.         flag := hdlflagtype(NewHandle(SizeOf(flagtype)));
  132.  
  133.         for i := 1 to numberfiles do
  134.             flag^^[i] := true;
  135.  
  136.         for i := 1 to numberfiles do
  137.             begin
  138.                 j := numberfiles + 1 - i;
  139.                 for k := 1 to j - 1 do
  140.                     begin
  141.                         if (tfilename^^[k] = tfilename^^[j]) then
  142.                             flag^^[k] := false;
  143.                     end;
  144.             end;
  145.  
  146.         for i := 1 to numberfiles do
  147.             if flag^^[i] then
  148.                 writeln(tfilename^^[i]);
  149.  
  150.         DisposHandle(handle(flag));
  151.  
  152.     end;
  153.  
  154.  
  155.     procedure listtfile;
  156.  
  157.         label
  158.             1;
  159.  
  160.         var
  161.             i, k: integer;
  162.             line: str255;
  163.  
  164.     begin
  165.  
  166.         for i := 1 to numberfiles do
  167.             if tfilename^^[i] = savename then
  168.                 begin
  169.                     k := i;
  170.                     if not tfileopen^^[k] then
  171.                         begin
  172.                             open(tfile^^[k], tfilename^^[k]);
  173.                             tfileopen^^[k] := true;
  174.                         end;
  175.                     reset(tfile^^[k]);
  176. 1:
  177.                     if not eof(tfile^^[k]) then
  178.                         begin
  179.                             readln(tfile^^[k], line);
  180.                             writeln(line);
  181.                             goto 1;
  182.                         end;
  183.                     close(tfile^^[k]);
  184.                     tfileopen^^[k] := false;
  185.                 end;
  186.  
  187.     end;
  188.  
  189.  
  190.     procedure ClearScreen;
  191.  
  192.  
  193.         var
  194.             m, place: integer;
  195.             removeblanks: boolean;
  196.             tfile: hdltextfilearray;
  197.             tfilename: hdlstringarray0;
  198.  
  199.     begin
  200.  
  201.         removeblanks := true;
  202.  
  203.         place := pos(blank, line);
  204.         while place <> 0 do
  205.             begin
  206.                 delete(line, place, 1);
  207.                 place := pos(blank, line);
  208.             end;
  209.  
  210.         m := pos('cls', line);
  211.         delete(line, m, 4);
  212.         if line <> '' then
  213.             writeln('cls is a reserved word for clearing the screen');
  214.         if line = '' then
  215.             rewrite(output);
  216.     end;
  217.  
  218.     procedure readvariables;
  219.  
  220.         var
  221.             i: integer;
  222.  
  223.     begin
  224.  
  225.         for i := 1 to maxnumberofstrings do
  226.             begin
  227.                 strvar^^[i] := '';
  228.                 strvartokentype^^[i] := '';
  229.                 val^^[i] := 0;
  230.             end;
  231.  
  232.         open(varfile, varfilename);
  233.         reset(varfile);
  234.         numvariables := 0;
  235.  
  236.         while not eof(varfile) do
  237.             begin
  238.                 numvariables := numvariables + 1;
  239.                 readln(varfile, strvar^^[numvariables]);
  240.                 readln(varfile, strvartokentype^^[numvariables]);
  241.                 readln(varfile, val^^[numvariables]);
  242.             end;
  243.  
  244.  
  245.     end;
  246.  
  247.  
  248.     procedure listvariables;
  249.  
  250.         var
  251.             i, j, k, m: integer;
  252.             varname: stringsize;
  253.             flag: hdlflagtype;
  254.  
  255.     begin
  256.  
  257.         flag := hdlflagtype(NewHandle(SizeOf(flagtype)));
  258.  
  259.         if numvariables > 0 then
  260.             for i := 1 to numvariables do
  261.                 flag^^[i] := true;
  262.         if numvariables > 0 then
  263.             for i := 1 to numvariables do
  264.                 begin
  265.                     j := numvariables + 1 - i;
  266.                     for k := 1 to j - 1 do
  267.                         begin
  268.                             if (strvar^^[k] = strvar^^[j]) then
  269.                                 flag^^[k] := false;
  270.                         end;
  271.                 end;
  272.         if numvariables > 0 then
  273.             for i := 1 to numvariables do
  274.                 if (strvartokentype^^[i] = 'real') and flag^^[i] then
  275.                     writeln(strvar^^[i], '   ', val^^[i] : decplaceplus10 : decplace);
  276.  
  277.         DisposHandle(handle(flag));
  278.  
  279.     end;
  280.  
  281.  
  282.     procedure deletevariable;
  283.  
  284.         label
  285.             3;
  286.  
  287.         var
  288.             i, k: integer;
  289.  
  290.     begin
  291.  
  292.         for i := 1 to numvariables do
  293.             if strvar^^[i] = savename then
  294.                 begin
  295.                     if i = numvariables then
  296.                         goto 3;
  297.                     for k := i to numvariables - 1 do
  298.                         begin
  299.                             strvar^^[k] := strvar^^[k + 1];
  300.                             val^^[k] := val^^[k + 1];
  301.                             strvartokentype^^[k] := 'real';
  302.                         end;
  303.                     goto 3;
  304.                 end;
  305. 3:
  306.         numvariables := numvariables - 1;
  307.  
  308.  
  309.     end;
  310.  
  311.  
  312.  
  313.     procedure storevariables;
  314.  
  315.         var
  316.             i, j, k, mtot: integer;
  317.             flag: hdlflagtype;
  318.  
  319.     begin
  320.  
  321.         decplace := 20;
  322.         decplaceplus10 := decplace + 10;
  323.  
  324.         flag := hdlflagtype(NewHandle(SizeOf(flagtype)));
  325.  
  326.         rewrite(varfile);
  327.         for i := 1 to numvariables do
  328.             flag^^[i] := false;
  329.         for i := 1 to numvariables do
  330.             begin
  331.                 k := numvariables + 1 - i;
  332.                 if flag^^[k] = false then
  333.                     for j := 1 to k - 1 do
  334.                         if (strvar^^[j] = strvar^^[k]) then
  335.                             flag^^[j] := true;
  336.             end;
  337.  
  338.         mtot := 0;
  339.         for i := 1 to numvariables do
  340.             if not flag^^[i] then
  341.                 begin
  342.                     mtot := mtot + 1;
  343.                     strvar^^[mtot] := strvar^^[i];
  344.                     strvartokentype^^[mtot] := strvartokentype^^[i];
  345.                     val^^[mtot] := val^^[i];
  346.                 end;
  347.         numvariables := mtot;
  348.  
  349.         for i := 1 to numvariables do
  350.             begin
  351.                 writeln(varfile, strvar^^[i]);
  352.                 writeln(varfile, strvartokentype^^[i]);
  353.                 writeln(varfile, val^^[i] : decplaceplus10 : decplace);
  354.             end;
  355.  
  356.         DisposHandle(handle(flag));
  357.  
  358.     end;
  359.  
  360.  
  361. end.